This appears to assert that unwrap(a) === unwrap(b) implies that a === b. That seems odd, but I guess does happen to be true most of the time. But that seems a bit strange because this PR then seems to be explicitly falsifiable per #29936 demonstrating that that assumed implication is bad.

The problem here is that there is a special serialization for unwrap(typename.wrapper), which jl_serialize_datatype detects by comparing the address of the DataType. So we serialized Val{x} where x such that the inner Val{x} got that special representation, but the UnionAll didn't match so it and its TypeVar were saved separately. So the deserializer constructed Val{x} where x, where the inner and outer x are different TypeVar objects, which is a malformed type. The intent of this change is to remove that discrepancy.

Another way to look at it is that if a::UnionAll === b::UnionAll is true, that does not imply that the addresses of a and b are the same, so comparing the addresses in C doesn't quite do what we want.

Right, I understand that's why this hides the bug. But just pointing out that it seems to potentially indicate a deeper issue, where we assume that TypeVar identity will be correctly maintained, but doesn't.

This is an example of what this PR could cause to fail (if it appeared in user code):

diff --git a/test/precompile.jl b/test/precompile.jl
index ed93b60bfd..d3417bfc8f 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -135,6 +135,8 @@ try
 
               const x28297 = Result(missing)
 
+              const d28297a = UnionAll(Dict.var, UnionAll(Dict.body.var, Dict.body.body)) # === Dict
+              const d28297b = UnionAll(Dict.body.var, UnionAll(Dict.var, Dict.body.body)) # === Dict{K,V} where K where V !== Dict
 
               # issue #28998
               const x28998 = [missing, 2, missing, 6, missing,
@@ -186,6 +188,8 @@ try
         @test Foo.abigint_x::BigInt + 1 == big"125"
 
         @test Foo.x28297.result === missing
+        @show Foo.d28297a # === Dict
+        @show Foo.d28297b # === Dict
 
         @test Foo.x28998[end] == 6
     end